package thread;

import java.util.LinkedList;
import java.util.Queue;

//编写代码, 实现阻塞队列案例
class MyBlockingQueue<E> {
    private Object[] queue;
    private final int defaultCapacity = 3;       // 阻塞队列的默认容量
    private int front;      // 指向队列的头部
    private int rear;       // 指向队列的尾部
    private int size;       // 记录当前队列的 元素个数
    public MyBlockingQueue() {
        queue = new Object[defaultCapacity + 1];
    }

    public void put (E value) throws InterruptedException {
        // 判断队列是否已满
        synchronized (this) {
            while (size == defaultCapacity) {
            // 队列进入阻塞状态， 直到有元素出队时 解除阻塞
                this.wait();
            }
            queue[rear] = value;
            size++;
            // 如果 rear自增 到达数组末尾，使 rear 重新到数组的头部
            rear = (rear + 1) % (defaultCapacity + 1);
            // 此处的 notify 用来唤醒 队列为空时的 wait
            this.notify();
        }
    }

    public E take() throws InterruptedException {
        // 判断队列是否为空
        synchronized (this) {
            while (rear == front) {
            // 队列进入阻塞状态，直到有新的元素入队时 解除阻塞
                this.wait();
            }
            Object ret = queue[front];
            // 如果 front 自增 到达数组末尾，使 front 重新到数组的头部
            front = (front + 1) % (defaultCapacity + 1);
            size--;
            // 此处的 notify 用来唤醒 队列为满时的 wait
            this.notify();
            return (E)ret;
        }
    }
    public int size() {
        return size;
    }

}
public class demo12 {
    public static void main(String[] args) throws InterruptedException {
        MyBlockingQueue<Integer> myBlockingQueue = new MyBlockingQueue<>();
        myBlockingQueue.put(11);
        myBlockingQueue.put(22);
        myBlockingQueue.put(33);
        myBlockingQueue.put(66);
        System.out.println("=====");
    }
}
